/**
 * Android接口JavaScript包装器
 * 提供与Android原生方法的通信接口
 */

// 存储待处理的请求回调
const pendingRequests = {};

/**
 * 初始化Android接口
 * @param {string} pageName 页面名称，用于日志记录
 */
function initAndroidInterface(pageName = '未命名页面') {
    try {
        // 检查Android接口
        const androidInterface = window.Android || window.AndroidInterface;
        if (androidInterface) {
            // 将找到的接口绑定到全局变量
            window.AndroidInterface = androidInterface;
            console.log(`[AndroidInterface] 初始化成功，页面: ${pageName}`);

            // 发送页面加载消息
            try {
                androidInterface.onMessageFromJs(`页面加载: ${pageName}`);
            } catch (e) {
                console.warn(`[AndroidInterface] 无法发送页面加载消息: ${e.message}`);
            }

            return true;
        } else {
            console.warn('[AndroidInterface] 接口不可用，可能在浏览器中运行');
            return false;
        }
    } catch (e) {
        console.error(`[AndroidInterface] 初始化失败: ${e.message}`);
        return false;
    }
}

/**
 * 处理来自Android的响应
 * 这个函数会被Android端调用
 * @param {string} requestId 请求ID
 * @param {Object|string} result 响应结果
 */
function handleNativeResponse(requestId, result) {
    try {
        const callback = pendingRequests[requestId];
        if (!callback) {
            console.warn(`[AndroidInterface] 未找到请求的回调函数，ID: ${requestId}`);
            return;
        }
        console.log("handleNativeResponse收到结果", result)

        // 将字符串解析为对象（如果需要）
        let parsedResult = result;
        if (typeof result === 'string' && (result.startsWith('{') || result.startsWith('['))) {
            try {
                parsedResult = JSON.parse(result);
                console.log("handleNativeResponse parse result", parsedResult)
            } catch (e) {
                // 解析失败，保持原始格式
            }
        }
        console.log("最终parsedResult：",parsedResult);

        // 处理响应并返回给调用者
        if (parsedResult && typeof parsedResult === 'object') {
            console.log("进入解析对象逻辑")
            
            // 检查是否是ApiResponse格式 (包含success字段)
            if ('success' in parsedResult) {
                console.log("检测到ApiResponse格式，包含success字段");
                if (parsedResult.success === true) {
                    // 处理data字段中的嵌套JSON字符串（如果有）
                    let data = parsedResult.data;
                    console.log("解析出来data数据",data);
                    if (typeof data === 'string' && (data.startsWith('{') || data.startsWith('['))) {
                        try {
                            data = JSON.parse(data);
                            console.log("进一步解析data数据")
                        } catch (e) {
                            // 解析失败，保持原始格式
                        }
                    }
                    
                    // 检查是否有PageResponseDto结构（包含list字段）
                    if (data && typeof data === 'object' && 'list' in data) {
                        console.log("检测到PageResponseDto格式，包含list字段");
                        // 已经是正确的格式，不需要额外处理
                    }
                    
                    // 直接返回ApiResponse格式
                    console.log("handleNativeResponse返回ApiResponse成功结果:", parsedResult);
                    callback(parsedResult);
                } else {
                    console.log("handleNativeResponse返回ApiResponse失败结果:", parsedResult);
                    callback(parsedResult);
                }
            }
            // 检查是否是旧的API响应格式 (包含code字段)
            else if ('code' in parsedResult) {
                console.log("检测到旧的API响应格式，包含code字段");
            if (parsedResult.code === 0 || parsedResult.code === 200) {
                // 处理data字段中的嵌套JSON字符串（如果有）
                let data = parsedResult.data;
                console.log("解析出来data数据",data);
                if (typeof data === 'string' && (data.startsWith('{') || data.startsWith('['))) {
                    try {
                        data = JSON.parse(data);
                        console.log("进一步解析data数据")
                    } catch (e) {
                        // 解析失败，保持原始格式
                    }
                }
                const result = { success: true, data: data };
                console.log("handleNativeResponse封装后的结果1:", result)
                    callback(result);
            } else {
                const result = {
                    success: false,
                    message: parsedResult.message || '未知错误',
                    code: parsedResult.code
                };
                console.log("handleNativeResponse封装后的结果2:", result)
                callback(result);
            }
        } else {
            // 非标准格式，直接返回
            const result = { success: true, data: parsedResult };
            console.log("handleNativeResponse封装后的结果3:", result)
            callback(result);
            }
        } else {
            // 非对象类型，直接包装返回
            const result = { success: true, data: parsedResult };
            console.log("handleNativeResponse封装后的非对象结果:", result)
            callback(result);
        }

        // 删除已处理的请求
        delete pendingRequests[requestId];
    } catch (e) {
        console.error(`[AndroidInterface] 处理响应出错: ${e.message}`);
    }
}

/**
 * 异步调用Android方法
 * @param {string} method 方法名
 * @param {Object|string} args 参数，可以是对象或字符串
 * @returns {Promise<any>} 返回Promise，resolve时传入Java方法的返回值
 */
function callAndroidMethodAsync(method, args = {}) {
    return new Promise((resolve, reject) => {
        try {
            // 获取Android接口
            const androidInterface = window.AndroidInterface || window.Android;

            if (!androidInterface) {
                throw new Error('Android接口不可用');
            }

            // 生成唯一请求ID
            const requestId = 'req_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);

            // 存储回调函数
            pendingRequests[requestId] = resolve;

            // 将参数转换为字符串
            let argsStr = typeof args === 'object' ? JSON.stringify(args) : String(args || '');

            console.log(`[AndroidInterface] 调用: ${method}, 参数: ${argsStr}`);

            // 调用原生方法
            androidInterface.onJsCall(method, argsStr, requestId);
        } catch (e) {
            console.error(`[AndroidInterface] 调用失败: ${e.message}`);
            reject(e);
        }
    });
}

/**
 * 判断当前是否在Android WebView环境中
 * @returns {boolean} 是否在Android WebView环境中
 */
function isAndroidWebView() {
    return !!(window.AndroidInterface || window.Android);
} 